/* eslint-disable */
import { getCodeList } from '@/api/dictionary'

export default {
  methods: {
    empty() {},
    loaded() {},
    handleCancel() {
      this.$router.push({
        path: '/siteconfig/datagroup'
      })
    },
    joinCheckedTree(data, checkedList) {
      data &&
        data.length > 0 &&
        data.forEach(item => {
          if (item.children && item.children.length) {
            this.joinCheckedTree(item.children, checkedList)
          }
          checkedList &&
            checkedList.length > 0 &&
            checkedList.forEach(check => {
              if (check === item.id) {
                this.selectedTableLevelArr.push(item) // 添加选中节点
              }
            })
        })
    },
    getTreeData(data) {
      if (data && data.length > 0) {
        this.joinCheckedTree(data, this.defaultCheckedTreeNodes)
        if (this.selectedTableLevelArr.length === 0) {
          this.tableLevel = '<未选择表、字段>'
        } else {
          this.tableLevel = this.selectedTableLevelArr
            .map(item => item.text)
            .join('、')
        }
      }
    },
    getDatagroupDimensionTreeData() {
      // 获取左侧维度树
      this.getDatagroupDimensionTreeInfo({ datagroupId: this.datagroupId })
        .then(({ success, data }) => {
          if (success) {
            this.checkNodes = []
            let cateId = data.dimensionCateId
            let fieldId = data.dimensionFieldId
            let tableId = data.dimensionTableId
            let dsId = data.dimensionDsId

            this.defaultCheckedTreeNodes = [
              ...dsId,
              ...cateId,
              ...fieldId,
              ...tableId
            ]

            this.dimensionDsId = dsId
            this.dimensionCateId = cateId
            this.dimensionFieldId = fieldId
            this.dimensionTableId = tableId
          } else {
            this.$message({
              type: 'error',
              message: '获取维度树信息失败'
            })
          }
        })
        .then(() => {
          // 获取维度左侧树数据
          this.getTreeData()
          // this.tableLevel = !!this.tableLevel ? this.tableLevel : "<未选择表、字段>"
        })
    },
    // 获取数据组相关信息填入表单内
    getDatagroupFormData() {
      new Promise((resolve, reject) => {
        this.getDatagroupInfo({ datagroupId: this.datagroupId })
          .then(({ success, data }) => {
            if (success) {
              this.$refs.datagroupForm && this.$refs.datagroupForm.resetFields()
              Object.keys(data).forEach(key => {
                for (key in this.form) {
                  if (key === 'isEnable') {
                    this.$set(this.form, key, !!data[key])
                  } else {
                    this.$set(this.form, key, data[key])
                  }
                }
              })
              resolve()
            } else {
              this.$message({
                type: 'error',
                message: '获取数据组信息失败'
              })
              reject(new Error('获取数据组信息失败'))
              this.$router.push({
                path: '/siteconfig/datagroup'
              })
            }
          })
          .catch(err => {
            console.log(err)
            reject(err)
          })
      })
    },
    // handleSubmit() {
    //   this.$refs.datagroupForm.validate(valid => {
    //     if (valid) {
    //       this.$refs.saveBtn.handleChangeStatus('handleSubmit',{ loading: true, icon: '' })
    //       this.handleGroup()
    //       this.sysDatagroup = this.$refs.datagroupForm.model
    //       this.sysDatagroup.datagroupId = this.datagroupId
    //       this.sysDatagroup.isEnable = this.sysDatagroup.isEnable === true ? 1 : 0
    //       const params = {
    //         sysDatagroup: this.sysDatagroup,
    //         dimensionBuseTypes: this.dimensionBuseTypes,
    //         dimensionDsId: this.dimensionDsId,
    //         dimensionCateId: this.dimensionCateId,
    //         dimensionFieldId: this.dimensionFieldId,
    //         dimensionTableId: this.dimensionTableId,
    //         levels: this.levels,
    //         operateType: this.operateType
    //       }
    //       new Promise((resolve, reject) => {
    //         this.add(params).then(({ success, message }) => {
    //           if (success) {
    //             this.$message({
    //               type: 'success',
    //               message
    //             })
    //             this.$refs.saveBtn.handleChangeStatus('handleSubmit',{ loading: true, icon: '' })
    //             resolve()
    //             this.$router.push({
    //               path: "/siteconfig/datagroup"
    //             })
    //           } else {
    //             this.$message({
    //               type: 'error',
    //               message
    //             })
    //             this.$refs.saveBtn.handleChangeStatus('handleSubmit',{ loading: false, icon: '' })
    //             reject(new Error(message))
    //           }
    //         }).catch(err => {
    //           console.log(err)
    //           this.$refs.saveBtn.handleChangeStatus('handleSubmit',{ loading: false, icon: '' })
    //           reject(err)
    //         })
    //       })
    //     } else {
    //       this.$message({
    //         type: 'info',
    //         message: '数据组编号或数据组名称未填'
    //       })
    //     }
    //   })
    // },
    // 编辑保存
    // handleEditSubmit() {
    //   this.$refs.datagroupForm.validate(valid => {
    //     if (valid) {
    //       this.$refs.saveBtn.handleChangeStatus('handleEditSubmit',{ loading: true, icon: '' })
    //       this.dimensionBuseTypes = []
    //       this.handleGroup()
    //       this.sysDatagroup = this.$refs.datagroupForm.model
    //       this.sysDatagroup.isEnable = this.sysDatagroup.isEnable === true ? 1 : 0
    //       const params = {
    //         sysDatagroup: JSON.stringify(this.sysDatagroup),
    //         dimensionBuseTypes: JSON.stringify(this.dimensionBuseTypes),
    //         dimensionDsId: JSON.stringify(this.dimensionDsId),
    //         dimensionCateId: JSON.stringify(this.dimensionCateId),
    //         dimensionFieldId: JSON.stringify(this.dimensionFieldId),
    //         dimensionTableId: JSON.stringify(this.dimensionTableId),
    //         levels: JSON.stringify(this.levels),
    //         operateType: this.operateType
    //       }
    //       new Promise((resolve, reject) => {
    //         this.update(params).then(({ success, message }) => {
    //           if (success) {
    //             this.$message({
    //               type: 'success',
    //               message
    //             })
    //             this.$refs.saveBtn.handleChangeStatus('handleEditSubmit',{ loading: true, icon: '' })
    //             resolve()
    //             this.$router.push({
    //               path: "/siteconfig/datagroup"
    //             })
    //           } else {
    //             this.$message({
    //               type: 'error',
    //               message
    //             })
    //             this.$refs.saveBtn.handleChangeStatus('handleEditSubmit',{ loading: false, icon: '' })
    //             reject(new Error(message))
    //           }
    //         }).catch(err => {
    //           console.log(err)
    //           this.$refs.saveBtn.handleChangeStatus('handleEditSubmit',{ loading: false, icon: '' })
    //           reject(err)
    //         })
    //       })
    //     } else {
    //       this.$message({
    //         type: 'info',
    //         message: '数据组编号或数据组名称未填'
    //       })
    //     }
    //   })
    // },
    // 处理业务类型为业务对象/机构情况
    handleGroup() {
      const objArr = this.defaultDemnsionData.filter(
        item => item.specialType === 3
      )
      let demNum = -1
      this.cItems.forEach(item => {
        var obj = {
          dicCodeType: '',
          bustypeObjId: '', // 业务id
          bustypeCondition: '', // 操作符 id
          bustypeDesc: '', // 条件
          bustypeDescbak: '',
          specialType: null // 单选框
        }
        if (item.cascaderValue[0] == '1') {
          // 特殊业务对象
          if (
            item.cascaderValue[1] === '88bc27b5-a9c2-11e8-aaa0-00ff592a9fc2'
          ) {
            obj.bustypeObjId = '88bc27b5-a9c2-11e8-aaa0-00ff592a9fc2' // 业务对象
            obj.specialType = item.radioVal
            if (Array.isArray(item.checkedTreeNodes)) {
              if (item.checkedTreeNodes && item.checkedTreeNodes.length > 0) {
                obj.bustypeDesc = []
                obj.bustypeDescbak = ''
                const idArr = []
                const pidArr = []
                item.groupTreeCheckedNodes.forEach(v => {
                  idArr.push(v.id)
                  pidArr.push(v.parentNode ? v.parentNode : '')
                })
                // 筛选出被全勾选的且非叶子节点的id值
                const filterIds = idArr.filter(idItem =>
                  [...new Set(pidArr)].includes(idItem)
                )
                // 剔除那些节点的parentNode（即父亲节点id值）在filterIds里的节点

                const filterNodes = item.groupTreeCheckedNodes.filter(
                  smallItem => !filterIds.includes(smallItem.parentNode)
                )
                obj.bustypeDescbak = filterNodes
                  .map(item => {
                    return item.groupNo
                  })
                  .join(',')
                item.checkedTreeNodes.forEach(_item => {
                  obj.bustypeDesc.push(_item.id)
                })
                obj.bustypeDesc = String(obj.bustypeDesc) // 树-传给后台的数据只要是id即可
              }
            } else {
              if (
                this.defaultCheckedSmallNodes.length > 0 &&
                objArr.length > 0
              ) {
                ++demNum
                obj.bustypeDescbak =
                  objArr[demNum].specialType === 3
                    ? objArr[demNum].bustypeDescbak
                    : ''
                obj.bustypeDesc =
                  objArr[demNum].specialType === 3
                    ? objArr[demNum].bustypeDesc
                    : ''
              } else {
                const temp = this.haveGetedDimensionData.filter(
                  dataSon => item.objId === dataSon.objId
                )[0]
                obj.bustypeDesc = temp.bustypeDesc
                obj.bustypeDescbak = temp.bustypeDescbak
              }
            }
          } else {
            // 普通业务对象
            obj.bustypeObjId = item.cascaderValue[1]
            obj.bustypeCondition = item.operatorsVal
            obj.bustypeDesc = item.conditions2Val
              ? item.conditions2Val
              : item.datesVal
          }
        } else if (item.cascaderValue[0] == '2') {
          // 代码
          obj.dicCodeType = item.cascaderValue[1]
          obj.bustypeCondition = item.codeOperatorsVal
          obj.bustypeDesc = item.conditionsVal
        }
        this.dimensionBuseTypes.push(obj)
      })
    },
    /**
     * 点击新增，生成一个折叠面板
     */
    handleAddCondition() {
      this.reloadSmallTreeFlag = true
      this.collapseIsShow = true // 显示折叠面板
      this.componentsSelectNum++
      this.cItems.push({
        cType: '',
        cascaderValue: [],
        componentName: '',
        radioVal: '',
        operatorsVal: '',
        conditionsVal: '',
        conditions2Val: '',
        datesVal: '',
        checkedTreeNodes: [],
        checkedTreeNodeNames: '',
        codeOperatorsVal: '',
        groupTreeCheckedNodes: [], // 存储每个条件中如果有选择机构树情况下机构树节点勾选
        refName: `ComponentsSelect${this.componentsSelectNum}`
      })
    },
    /**
     * 点击每一列的删除,关闭折叠面板
     */
    // eslint-disable-next-line
    closeCollapse(item) {
      this.cItems.splice(this.cItems.indexOf(item), 1)
      this.cItems.length === 0
        ? (this.noCondition = '<无条件>')
        : (this.noCondition = '')
    },
    handleChange(item, val) {
      const srcObj = {
        cType: '',
        cascaderValue: [],
        componentName: '',
        radioVal: '', // 值有'',1，2，3 ''表示业务对象为非机构，1代表本机构 2代表本机构及下级机构 3代表其他机构及下级机构
        operatorsVal: '',
        conditionsVal: '',
        conditions2Val: '',
        conditionsDirectoryVal: [], // 必须添加，否则watch不到数据变化，条件下拉选择始终无数据
        datesVal: '',
        checkedTreeNodes: [],
        checkedTreeNodeNames: '',
        codeOperatorsVal: '',
        groupTreeCheckedNodes: [], // 存储每个条件中如果有选择机构树情况下机构树节点勾选
        refName: 'ComponentsSelect',
        bustypeDesc: '',
        bustypeDescbak: ''
      }
      Object.assign(this.conditionObj, srcObj)
      this.conditionObj.cascaderValue = val
      item.cascaderValue = val
      // 从后台获取条件（select下拉框）的数据
      // 获取条件（select下拉框）的数据根绝代码选中的值来变化
      getCodeList(val[1]).then(({ success, data }) => {
        if (success) {
          this.directoryItems = data
          item.conditionsDirectoryVal = data
        }
      })

      if (~val.indexOf('1')) {
        if (val[1] == '88bc27b5-a9c2-11e8-aaa0-00ff592a9fc2') {
          item.componentName = 'SpecialObj' // 特殊业务类型
        } else {
          item.componentName = 'CommonObj' // 普通业务类型
          this.cascaderOptions[0].children.forEach(option => {
            if (option.value == val[1]) {
              // 判断普通业务类型下的输入条件的不同形式
              if (option.formatType === 'TM') {
                // 日期
                this.dateIsShow = true
                this.inputIsShow = false
              } else {
                // input输入框（又分为两种，分别为只能输入数字的输入框和可以输入任何值的输入框）
                this.dateIsShow = false
                this.inputIsShow = true
              }
            }
          })
        }
      } else {
        item.componentName = 'Codes'
      }
    },
    /**
     * 获取左侧树勾选的值
     */
    checkNode(val) {
      this.checkNodes = [...val]
      this.tableLevel = ''
      if (this.checkNodes.length) {
        this.tableLevel = this.checkNodes.map(item => item.text).join('、')
      } else {
        this.tableLevel = '<未选择表、字段>'
      }
      this.initCheckedNode()
      val.forEach(item => {
        if (item.type === 'cate') {
          this.dimensionCateId.push(item.id) // 存储传给后台树的第一二层的id
        } else if (item.type === 'table') {
          this.dimensionTableId.push(item.id) // 存储传给后台树的第三层的id
        } else if (item.type === 'field') {
          this.dimensionFieldId.push(item.id) // 存储传给后台树的第四层的id
        } else if (item.type === 'ds') {
          this.dimensionDsId.push(item.id)
        }
      })
      // 去重
      this.dimensionDsId = [...new Set(this.dimensionDsId)]
      this.dimensionCateId = [...new Set(this.dimensionCateId)]
      this.dimensionTableId = [...new Set(this.dimensionTableId)]
      this.dimensionFieldId = [...new Set(this.dimensionFieldId)]
    },
    initCheckedNode() {
      this.dimensionDsId = []
      this.dimensionCateId = []
      this.dimensionTableId = []
      this.dimensionFieldId = []
    },
    // 从后台获取业务对象的数据
    getBusinessobject() {
      new Promise((resolve, reject) => {
        this.getBusinessobjectData()
          .then(({ success, data }) => {
            if (success) {
              this.businessobjectData = data
              data.forEach(item => {
                const obj = {}
                obj.label = item.objName
                obj.value = item.objId
                obj.formatType = item.formatType
                this.cascaderOptions[0].children = []
                this.$nextTick(() => {
                  this.cascaderOptions[0].children.push(obj) // 获取业务对象的数据，并根据需要修改其形式
                })
              })
              resolve()
            } else {
              this.$message({
                type: 'error',
                message: '获取业务对象数据失败'
              })
              reject(new Error('获取业务对象数据失败'))
            }
          })
          .catch(err => {
            console.log(err)
            reject(err)
          })
      })
    },
    // 从后台获取代码的数据
    getCodeTypeListFn() {
      const prevEdit = () => {
        return this.getDimensionBustypeData({
          datagroupId: this.datagroupId
        })
          .then(({ success, data }) => {
            if (!success) {
              throw new Error('error')
            }
            this.noCondition = data.length > 0 ? '' : '<无条件>'
            this.defaultDemnsionData = data
            this.haveGetedDimensionData = data
            this.cItems = []
            data.forEach(item => {
              this.componentsSelectNum++
              const obj = {
                dicCodeType: item.dicCodeType,
                objId: '',
                conditionsDirectoryVal: []
              }

              /**
               *  ！业务对象
               */
              if (!item.bustypeObjId) {
                /**
                 * 代码
                 */
                obj.cType = 'codeType'
                obj.componentName = 'Codes'
                obj.cascaderValue = ['2', item.dicCodeType] // 业务对象
                obj.codeOperatorsVal = item.bustypeCondition // 运算符
                obj.conditionsVal = +item.bustypeDesc // 条件
              } else if (item.specialType != 0) {
                /**
                 * 特殊业务对象
                 */

                obj.cType = 'specialType'
                obj.componentName = 'SpecialObj'
                obj.radioVal = item.specialType + '' // 单选框
                if (item.bustypeDesc) {
                  this.showSmallTree = true
                  obj.checkedTreeNodeNames = ''
                  // 根据返回机构树的id获取对应名称
                  this.getGroupTreeNodeNames({
                    groupIds: item.bustypeDesc
                  }).then(({ success, data }) => {
                    if (success) {
                      obj.checkedTreeNodeNames = data.groupName
                        .split(',')
                        .map(dataItem => dataItem)
                        .join('、')
                    } else {
                      this.$message({
                        type: 'error',
                        message: '获取机构树数据节点名称失败'
                      })
                    }
                  })
                }
                obj.objId = item.objId
                obj.cascaderValue = ['1', item.bustypeObjId] // 业务对象
              } else {
                /**
                 * 普通业务对象
                 */
                obj.cType = 'commonType'
                obj.componentName = 'CommonObj'
                obj.cascaderValue = ['1', item.bustypeObjId] // 业务对象
                obj.operatorsVal = item.bustypeCondition // 运算符

                if (item.formatType === 'TM') {
                  this.dateIsShow = true
                  obj.datesVal = item.bustypeDesc // 条件
                } else {
                  this.inputIsShow = true
                  obj.conditions2Val = item.bustypeDesc // 条件
                }
              }
              obj.refName = `ComponentsSelect${this.componentsSelectNum}`
              this.cItems.push(obj)
            })

            /**
             * 代码类型决定着输入条件（slect下拉框）的值，需一一对应
             */
            this.cItems.forEach(item => {
              if (item.cType === 'codeType' && item.dicCodeType) {
                getCodeList(item.dicCodeType).then(({ data }) => {
                  item.conditionsDirectoryVal = data
                })
              }
            })
            this.collapseIsShow = true // 显示折叠面板
          })
          .catch(error => {
            console.log('getDimensionBustypeData:::', error)
          })
      }
      // this.cascaderOptions[1].children.length === 0 && this.getCodeTypeList()
      this.getCodeTypeListInfo().then(({ success, data }) => {
        if (success) {
          this.getCodeTypeListData = data
          this.cascaderOptions[1].children = data.map(item => {
            // 获取代码的数据，并根据需要修改其形式
            return {
              value: item.type,
              label: item.name
            }
          })
          if (this.datagroupId !== '') {
            /**
             * 修改-新增条件
             */
            prevEdit()
          } else {
            this.cItems = []
          }
        } else {
          this.$message({
            type: 'error',
            message: '获取代码数据失败'
          })
        }
      })
    },
    // 从后台获取运算符数据
    getResultsymbol() {
      new Promise((resolve, reject) => {
        this.getResultsymbolData()
          .then(({ success, data }) => {
            if (success) {
              this.resultsymbolData = data
              resolve()
            } else {
              this.$message({
                type: 'error',
                message: '获取运算符数据失败'
              })
              reject(new Error('获取运算符数据失败'))
            }
          })
          .catch(err => {
            console.log(err)
            reject(err)
          })
      })
    }
  }
}
